Test executive with external process isolation for user code modules

ABSTRACT

A system and method for isolating execution of user-supplied code modules that are called by steps of a test executive sequence. The test executive sequence may first be created by including a plurality of test executive steps in the test executive sequence and configuring at least a subset of the steps to call user-supplied code modules. The test executive sequence may then be executed on a host computer under control of a test executive engine. For each step that calls a user-supplied code module, the test executive engine may invoke the user-supplied code module for execution in a separate process other than the process in which the test executive engine executes.

PRIORITY CLAIM

This application claims benefit of priority of U.S. ProvisionalApplication Ser. No. 60/637,997 titled “Test Executive with Features forDetecting and Preventing Errors in User-Supplied Code Modules Called bySteps of a Test Executive Sequence,” filed Dec. 21, 2004, whoseinventors were James A. Grey, Erik Crank, Douglas Melamed, and ScottRichardson.

FIELD OF THE INVENTION

The present invention relates to the field of test executive softwarefor organizing and executing test executive sequences. In particular,the invention relates to a system and method for executing user-suppliedcode modules called by steps of a test executive sequence in an externalprocess from a test executive engine that manages execution of the testexecutive sequence.

DESCRIPTION OF THE RELATED ART

Test executive software is specialized software that allows a user tocreate and execute test executive sequences to test units under test(IUTs). The test executive software operates as a control center for anautomated test system. More specifically, the test executive softwareallows the user to create, configure, and control execution of testexecutive sequences for various test applications, such as productionand manufacturing test applications. Text executive software typicallyincludes various features such as test sequencing based on pass/failresults, logging of test results, and test report generation, amongothers.

A test executive sequence may include a plurality of steps, and one ormore of the steps may call user-supplied code modules, also referred toherein as test modules. As used herein, a user-supplied code module ortest module refers to a software module that is written or supplied by auser of the test executive software. The user may construct various testmodules designed to perform tests on a UUT, and execution of these testmodules may be invoked by steps in a test executive sequence when thesequence is executed. For example, the test modules may interact withone or more hardware instruments to test the UUT(s).

The test executive software typically includes a sequence editor forcreating test executive sequences and a test executive engine operableto execute the test executive sequences. Executing a test executivesequence may comprise executing each of the steps in the test executivesequence, e.g., executing each of the steps according to an orderdefined by the test executive sequence.

For each step in the test executive sequence that calls a user-suppliedcode module, executing the step may comprise both executing programinstructions of the test executive engine and executing theuser-supplied code module. For example, in addition to calling auser-supplied code module, a step in a test executive sequence may alsoperform additional functionality, where the additional functionality isimplemented by the test executive engine and not coded by the user. Forexample, the step may be operable to perform common functionality whichis useful for various automated test applications, where the commonfunctionality is implemented by the test executive engine. This mayremove the burden on the user from implementing this functionality forthe step, thus increasing the user's ease and efficiency of creating theautomated test system.

As one example, the test executive engine may implement automatic resultcollection for a step in a test executive sequence. For example, whenthe step is executed during execution of the test executive sequence,the test executive engine may first invoke execution of a user-suppliedcode module called by the step. The user-supplied code module mayexecute to perform a specific test of a UUT. The user-supplied codemodule may conform to a programming interface through which itsexecution results can be passed back to the test executive engine. Whenthe user-supplied code module finishes execution, the test executiveengine may be operable to automatically receive the execution results ofthe module and log them in a report file or database. Thus, in thisexample, the user may implement the specific test functionalityperformed by the user-supplied code module but may not be required toimplement the functionality of logging the execution results of theuser-supplied code module since the logging is performed automaticallyby the test executive engine.

In some instances a test executive sequence may also include one or moresteps that do not call user-supplied code modules. For example, thefunctionality of some steps may be implemented entirely by the testexecutive engine and may not be coded by the user. However, the testexecutive software, e.g., the sequence editor, may allow the user to setvarious properties or parameters affecting operation of the steps, e.g.,by interacting with a dialog box or other graphical user interfaceassociated with the steps.

In some prior test executive systems, user-supplied code modules executein the same process space as the test executive engine. When theuser-supplied code modules contain bugs such as heap corruption errors,stack corruption errors, or other bugs, they can sometimes result in acrash in the test executive engine because of the shared process space.Because memory corruption or other bugs in a user supplied code modulecan lead to a crash or odd behavior that happens long after theuser-supplied code module finishes execution, it can be difficult forusers to determine the source of the error. If a bug in a user-suppliedcode module causes a crash in the test executive application, it can beinterpreted by the user as a vendor bug. This can distract the user fromfocusing on where the problem is really located and can create amistaken bad impression of the vendor's test executive application.

The symptoms of problems caused by bugs in user-supplied code modulescan be intermittent, difficult to reproduce, and subject to changing orto temporarily disappearing when anything about the system is modified,including modifications intended to help diagnose the problem. Becauseof this lack of repeatability, these types of bugs are among the mostdifficult to resolve. They are sometimes referred to as “Heisenbugs”,because any attempt to narrow down the problem can change the problemsymptoms, somewhat analogous to how any attempt to more accuratelydetermine the location of an electron only makes its momentum moreuncertain (from the Heisenberg uncertainty principle). Thus, it would bedesirable to provide users with a test executive application that helpsthem more easily track down bugs in user-supplied code modules.

SUMMARY

One embodiment of the invention comprises a system and method forisolating execution of user-supplied code modules that are called bysteps of a test executive sequence. The test executive sequence mayfirst be created by including a plurality of test executive steps in thetest executive sequence and configuring at least a subset of the stepsto call user-supplied code modules. For example, a user may interactwith a sequence editor which provides a graphical user interface forcreating and configuring the test executive sequence. In one embodiment,process isolation may be enabled or turned on for user-supplied codemodules called by at least a subset of the test executive steps in thetest executive sequence. As described below, for each user-supplied codemodule for which process isolation is enabled, a test executive enginemay be operable to invoke the user-supplied code module for execution ina separate process other than the process in which the test executiveengine executes.

In one embodiment the user may provide user input indicating whichuser-supplied code modules to perform process isolation for. In anotherembodiment, process isolation may be performed by default for alluser-supplied code modules called by steps in the test executivesequence. In this embodiment the test executive application may allowthe process isolation to be disabled or turned off for certain steps orcertain user-supplied code modules if desired.

After the test executive sequence has been created, the test executivesequence may be executed on a host computer under control of the testexecutive engine. Executing the test executive sequence may comprise thetest executive engine executing each of the steps in the test executivesequence. In one embodiment a step may have “pre-functionality” that isimplemented by the test executive engine, i.e., functionality to beperformed before a user-supplied code module called by the step isexecuted. Thus, in executing the step, the test executive engine mayfirst execute the pre-functionality of the step in a first process. Inother words, the first process is the process in which the testexecutive engine itself executes.

For each step that calls a user-supplied code module for which processisolation is enabled, the test executive engine may invoke theuser-supplied code module called by the step for execution in anotherprocess separate from the first process. Thus, execution of theuser-supplied code module called by the step may be isolated in anexternal process. This may prevent any bugs in the user-supplied codemodule from corrupting memory in the test executive engine's process orotherwise affecting execution of the test executive engine.

In one embodiment a step may have “post-functionality” that isimplemented by the test executive engine, i.e., functionality to beperformed after the user-supplied code module called by the stepfinishes executing. If the step has post-functionality then executingthe step may comprise the test executive engine executing thepost-functionality of the step in the first process after theuser-supplied code module called by the step finishes executing.

BRIEF DESCRIPTION OF THE DRAWINGS

A better understanding of the present invention can be obtained when thefollowing detailed description of the preferred embodiment is consideredin conjunction with the following drawings, in which:

FIG. 1 illustrates an exemplary automated test system according to oneembodiment;

FIG. 2 is a diagram representing one embodiment of the computer systemillustrated in FIG. 1;

FIG. 3 is a diagram illustrating high-level architectural relationshipsbetween elements of a test executive software application according toone embodiment;

FIG. 4 illustrates one example of a test executive sequence, createdaccording to one embodiment of a sequence editor;

FIG. 5 illustrates an exemplary GUI panel for a test executive step,which enables the user to specify various properties for the step thataffect the way the test executive engine manages the execution of thestep; and

FIG. 6 is a flowchart diagram illustrating one embodiment of a methodfor isolating one or more user-supplied code modules called by steps ofa test executive sequence for execution in a separate process other thanthe process in which the test executive engine executes.

While the invention is susceptible to various modifications andalternative forms, specific embodiments thereof are shown by way ofexample in the drawings and are herein described in detail. It should beunderstood, however, that the drawings and detailed description theretoare not intended to limit the invention to the particular formdisclosed, but on the contrary, the intention is to cover allmodifications, equivalents and alternatives falling within the spiritand scope of the present invention as defined by the appended claims.

DETAILED DESCRIPTION INCORPORATION BY REFERENCE

The following references are hereby incorporated by reference in theirentirety as though fully and completely set forth herein.

U.S. Pat. No. 6,401,220 titled “Test Executive System and MethodIncluding Step Types for Improved Configurability,” issued Jun. 4, 2002.

U.S. patent application Ser. No. 09/944,546 titled “System and MethodEnabling Execution Stop and Restart of a Test Executive Sequence(s),”filed Aug. 31, 2001.

U.S. patent application Ser. No. 10/056,853 titled “Test ExecutiveSystem Having XML Reporting Capabilities,” filed Jan. 25, 2002.

Terms

The following is a glossary of terms used in the present application:

User-Supplied Code Module—A software module or component written by auser. A user-supplied code module may be constructed or packaged in anyof various ways and may be created using any of various programmingtools or application development environments. For example, auser-supplied code module may be implemented as a function in a WindowsDynamic Link Library (DLL), a LabVIEW graphical program (VI), an ActiveXcomponent, a Java component, or other type of program module orcomponent that implements a specific test or other functionality.

Test Module—A user-supplied code module that performs a test of a UUT.

Test Executive Step—An action that the user can include within a testexecutive sequence. A step may call a user-supplied code module, e.g.,may call a test module to perform a specific test of a UUT. The step mayhave properties or parameters that can be set by the user, e.g., througha dialog box or other graphical user interface. In addition to calling auser-supplied code module, a step may also have built-in functionalityimplemented by the test executive software.

Step Module—The user-supplied code module that a test executive stepcalls.

Test Executive Sequence—A plurality of test executive steps that theuser specifies for execution in a particular order. Whether and when astep is executed can depend on the results of previous steps. A testexecutive sequence may be created using a sequence editor. For example,the sequence editor may create a sequence file or other data structurerepresenting the test executive sequence. A test executive sequence maybe executed by a test executive engine.

Sequence File—A file that contains the definition of one or more testexecutive sequences.

Sequence Editor—A program that provides a graphical user interface forcreating, editing, and debugging sequences. One embodiment of a sequenceeditor is described in detail below.

Test Executive Engine—A program operable to execute a test executivesequence. One embodiment of a test executive engine is described indetail below.

Run-time Operator Interface Application—An application program thatprovides a graphical user interface for controlling execution of testexecutive sequences, e.g., on a production station. For example, thegraphical user interface of the run-time operator interface applicationmay allow a test operator to start and stop execution of the testexecutive sequences. A sequence editor and run-time operator interfaceapplication can be separate programs or different aspects of the sameprogram. The test executive engine may provide an applicationprogramming interface (API) which the run-time operator interfaceapplication calls to control execution of the test executive sequences.

Application Development Environment (ADE)—A programming environment suchas LabVIEW, LabWindows/CVI, Microsoft Visual C++, Microsoft VisualBasic, etc., in which a user can create user-supplied code modules andrun-time operator interface applications.

Unit Under Test (UUT)—A physical device or component that is beingtested.

Memory Medium—Any of various types of memory devices or storage devices.The term “memory medium” is intended to include an installation medium,e.g., a CD-ROM, floppy disks 104, or tape device; a computer systemmemory or random access memory such as DRAM, DDR RAM, SRAM, EDO RAM,Rambus RAM, etc.; or a non-volatile memory such as a magnetic media,e.g., a hard drive, or optical storage. The memory medium may compriseother types of memory as well, or combinations thereof. In addition, thememory medium may be located in a first computer in which the programsare executed, or may be located in a second different computer whichconnects to the first computer over a network, such as the Internet. Inthe latter instance, the second computer may provide programinstructions to the first computer for execution. The term “memorymedium” may include two or more memory mediums which may reside indifferent locations, e.g., in different computers that are connectedover a network.

Carrier Medium—a memory medium as described above, as well as signalssuch as electrical, electromagnetic, or digital signals, conveyed via acommunication medium such as a bus, network and/or a wireless link.

Programmable Hardware Element—includes various types of programmablehardware, reconfigurable hardware, programmable logic, orfield-programmable devices (FPDs), such as one or more FPGAs (FieldProgrammable Gate Arrays), or one or more PLDs (Programmable LogicDevices), such as one or more Simple PLDs (SPLDs) or one or more ComplexPLDs (CPLDs), or other types of programmable hardware. A programmablehardware element may also be referred to as “reconfigurable logic”.

Medium—includes one or more of a memory medium, carrier medium, and/orprogrammable hardware element; encompasses various types of mediums thatcan either store program instructions/data structures or can beconfigured with a hardware configuration program.

Program—the term “program” is intended to have the full breadth of itsordinary meaning. The term “program” includes 1) a software programwhich may be stored in a memory and is executable by a processor or 2) ahardware configuration program useable for configuring a programmablehardware element.

Software Program—the term “software program” is intended to have thefull breadth of its ordinary meaning, and includes any type of programinstructions, code, script and/or data, or combinations thereof, thatmay be stored in a memory medium and executed by a processor. Exemplarysoftware programs include programs written in text-based programminglanguages, such as C, C++, Pascal, Fortran, Cobol, Java, assemblylanguage, etc.; graphical programs (programs written in graphicalprogramming languages); assembly language programs; programs that havebeen compiled to machine language; scripts; and other types ofexecutable software. A software program may comprise two or moresoftware programs that interoperate in some manner.

Hardware Configuration Program—a program, e.g., a netlist or bit file,that can be used to program or configure a programmable hardwareelement.

Graphical Program—A program comprising a plurality of interconnectednodes or icons, wherein the plurality of interconnected nodes or iconsvisually indicate functionality of the program.

Data Flow Graphical Program (or Data Flow Diagram)—A graphical programor diagram comprising a plurality of interconnected nodes, wherein theconnections between the nodes indicate that data produced by one node isused by another node.

Graphical User Interface—this term is intended to have the full breadthof its ordinary meaning. The term “graphical user interface” is oftenabbreviated to “GUI”. A GUI may comprise only one or more input GUIelements, only one or more output GUI elements, or both input and outputGUI elements.

The following provides examples of various aspects of GUIs. Thefollowing examples and discussion are not intended to limit the ordinarymeaning of GUI, but rather provide examples of what the term “graphicaluser interface” encompasses:

A GUI may comprise a single window, panel, or dialog box having one ormore GUI Elements, or may comprise a plurality of individual GUIElements (or individual windows each having one or more GUI Elements),wherein the individual GUI Elements or windows may optionally be tiledtogether.

Graphical User Interface Element—an element of a graphical userinterface, such as for providing input or displaying output. Exemplarygraphical user interface elements include input controls and outputindicators

Input Control—a graphical user interface element for providing userinput to a program. Exemplary input controls include buttons, checkboxes, input text boxes, knobs, sliders, etc.

Output Indicator—a graphical user interface element for displayingoutput from a program. Exemplary output indicators include charts,graphs, gauges, output text boxes, numeric displays, etc. An outputindicator is sometimes referred to as an “output control”.

Computer System—any of various types of computing or processing systems,including a personal computer system (PC), mainframe computer system,workstation, network appliance, Internet appliance, personal digitalassistant (PDA), television system, grid computing system, or otherdevice or combinations of devices. In general, the term “computersystem” can be broadly defined to encompass any device (or combinationof devices) having at least one processor that executes instructionsfrom a memory medium.

Measurement Device—includes instruments, data acquisition devices, smartsensors, and any of various types of devices that are operable toacquire and/or store data from a UUT. A measurement device may alsooptionally be further operable to analyze or process the acquired orstored data. Examples of a measurement device include an instrument,such as a traditional stand-alone “box” instrument, a computer-basedinstrument (instrument on a card) or external instrument, a dataacquisition card, a device external to a computer that operatessimilarly to a data acquisition card, a smart sensor, one or more DAQ ormeasurement cards or modules in a chassis, an image acquisition device,such as an image acquisition (or machine vision) card (also called avideo capture board) or smart camera, a motion control device, a robothaving machine vision, and other similar types of devices. Exemplary“stand-alone” instruments include oscilloscopes, multimeters, signalanalyzers, arbitrary waveform generators, spectroscopes, and similarmeasurement, test, or automation instruments.

A measurement device may be further operable to perform controlfunctions, e.g., in response to analysis of the acquired or stored data.For example, the measurement device may send a control signal to anexternal system, such as a motion control system or to a sensor, inresponse to particular data. A measurement device may also be operableto perform automation functions, i.e., may receive and analyze data, andissue automation control signals in response.

FIG. 1—Instrumentation System

FIG. 1 illustrates an exemplary automated test system 100, according toone embodiment. It is noted that FIG. 1 is exemplary only, and thepresent invention may be used in conjunction with any of varioussystems, as desired. The system 100 comprises a host computer 102 thatconnects to one or more instruments. The host computer 102 comprises aCPU, a display screen, memory, and one or more input devices such as amouse or keyboard as shown.

The computer 102 may execute a test executive sequence operable toanalyze, measure, control, or otherwise test a unit under test (UUT) orprocess 150. For example, the test executive sequence may includevarious steps that invoke software test modules operable to connectthrough the one or more instruments to analyze, measure, or control theunit under test (UUT) or process 150. The software test modules that areinvoked or called by the steps in the test executive sequence maycomprise user-supplied code modules. In other words, the test modulesmay be written or supplied by a user of the test executive software.

The test executive software may include a test executive engine 220operable to execute the test executive sequence. As described above,when user-supplied code modules called by steps in the test executivesequence contain bugs, these bugs can cause the test executive engine220 to crash if the user-supplied code modules are executed in the sameprocess space as the test executive engine. Thus, in one embodiment thetest executive engine 220 may be operable to invoke the user-suppliedcode modules for execution in a separate process, as described in detailbelow.

Referring again to FIG. 1, the one or more instruments of the automatedtest system 100 may include a GPIB instrument 112 and associated GPIBinterface card 122, a data acquisition board 114 and associated signalconditioning circuitry 124, a VXI instrument 116, a PXI instrument 118,a video device 132 and associated image acquisition card 134, a motioncontrol device 136 and associated motion control interface card 138,and/or one or more computer based instrument cards 142, among othertypes of devices.

The GPIB instrument 112 may be coupled to the computer 102 via a GPIBinterface card 122 provided by the computer 102. In a similar manner,the video device 132 may be coupled to the computer 102 via the imageacquisition card 134, and the motion control device 136 may be coupledto the computer 102 through the motion control interface card 138. Thedata acquisition board 114 may be coupled to the computer 102, andoptionally interfaces through signal conditioning circuitry 124 to theWUT. The signal conditioning circuitry 124 may include an SCXI (SignalConditioning eXtensions for Instrumentation) chassis comprising one ormore SCXI modules 126.

The GPIB card 122, the image acquisition card 134, the motion controlinterface card 138, and the DAQ card 114 are typically plugged in to anI/O slot in the computer 102, such as a PCI bus slot, a PC Card slot, oran ISA, EISA or MicroChannel bus slot provided by the computer 102.However, these cards 122, 134, 138 and 114 are shown external tocomputer 102 for illustrative purposes. The cards 122, 134, 138 and 114may also be implemented as external devices coupled to the computer 102,such as through a serial bus.

The VXI chassis or instrument 116 may be coupled to the computer 102 viaa serial bus, MXI bus, or other serial or parallel bus provided by thecomputer 102. The computer 102 preferably includes VXI interface logic,such as a VXI, MXI or GPIB interface card (not shown), which interfacesto the VXI chassis 116. The PXI chassis or instrument is preferablycoupled to the computer 102 through the computer's PCI bus.

A serial instrument (not shown) may also be coupled to the computer 102through a serial port, such as an RS-232 port, USB (Universal Serialbus) or IEEE 1394 or 1394.2 bus, provided by the computer 102. Intypical systems an instrument will not be present of each interfacetype, and in fact many systems may only have one or more instruments ofa single interface type, such as only GPIB instruments.

The instruments may be coupled to the unit under test (UUT) or process150, or may be coupled to receive field signals, typically generated bytransducers. Other types of instruments or devices may be connected tothe automated test system 100, as desired.

The computer 102 may include or may access a memory medium on which testexecutive software is stored. For example, the test executive softwaremay include a test executive engine 220 which is operable to executetest executive sequences. The test executive software may also includecomponents operable to create and configure test executive sequences, asdescribed below. For example, the memory medium may store a sequenceeditor 212 such as described below. In one embodiment the memory mediummay also store one or more test executive sequences to be executed onthe computer 102, as well as possibly storing one or more user-suppliedcode modules called by steps in the test executive sequences. In oneembodiment, one or more of the software elements described above may beincluded on remote computer systems.

FIG. 2—Computer System Block Diagram

FIG. 2 is a diagram of the computer system 102 illustrated in FIG. 1,according to one embodiment. It is noted that any type of computersystem configuration or architecture can be used as desired, and FIG. 2illustrates a representative PC embodiment. It is also noted that thecomputer system 102 may be a general purpose computer system, a computerimplemented on a VXI card installed in a VXI chassis, a computerimplemented on a PXI card installed in a PXI chassis, or other types ofembodiments. Elements of a computer not necessary to understand thepresent invention have been omitted for simplicity.

In the illustrated embodiment, the computer 102 includes at least onecentral processing unit or CPU 160 that is coupled to a processor orhost bus 162. The CPU 160 may be any of various types, including an x86processor, e.g., a Pentium class, a PowerPC processor, a CPU from theSPARC family of RISC processors, as well as others. Main memory 166 iscoupled to the host bus 162 by means of memory controller 164. The mainmemory 166 may store software such as the software elements describedabove with reference to FIG. 1. The main memory 166 may also storeoperating system software as well as other software for operation of thecomputer system, as well known to those skilled in the art. The CPU 160executing code and data from the main memory 166 may comprise a meansfor implementing the methods described below.

The host bus 162 is coupled to an expansion or input/output bus 170 bymeans of a bus controller 168 or bus bridge logic. The expansion bus 170may be the PCI (Peripheral Component Interconnect) expansion bus,although other bus types can also be used. The expansion bus 170 mayinclude slots for various devices such as the data acquisition board 114(of FIG. 1) and a GPIB interface card 122 that provides a GPIB businterface to the GPIB instrument 112 (of FIG. 1). A video displaysubsystem 180 and hard drive 182 coupled to the expansion bus 170 isalso shown.

In one embodiment, a reconfigurable instrument 190 may also be connectedto the computer 102. The reconfigurable instrument 190 may include afunctional unit, also referred to as configurable logic, such as aprogrammable logic element, e.g., an FPGA, or a processor and memory,which may execute a real time operating system. Program instructions maybe downloaded and executed on the reconfigurable instrument 190. In oneembodiment, at least a portion of the software described herein mayexecute on the reconfigurable instrument 190. In various embodiments,the functional unit may be included on an instrument or device connectedto the computer through means other than an expansion slot, e.g., theinstrument or device may be connected via an IEEE 1394 bus, USB, orother type of port. Also, the functional unit may be included on adevice such as the data acquisition board 114 or another device shown inFIG. 1.

Test Executive Software Components

FIG. 3 is a block diagram illustrating high-level architecturalrelationships between elements of a test executive software applicationaccording to one embodiment. It is noted that FIG. 3 is exemplary, andin other embodiments the test executive software may have differentarchitectures.

In the embodiment illustrated in FIG. 3, the test executive softwareincludes a sequence editor 212 for creating and editing test executivesequences. The sequence editor 212 may interface to a test executiveengine 220. In one embodiment, one or more process models 222 may coupleto the test executive engine 220. The test executive engine 220 mayinterface through an adapter interface 232 to one or more adapters 240.The adapters 240 shown in FIG. 3 include a LabVIEW standard prototypeadapter, a C/CVI prototype adapter, a DLL flexible prototype adapter,and a sequence adapter. The LabVIEW standard prototype adapter mayinterface to user-supplied code modules having a .VI extension, i.e.,LabVIEW graphical programs. The C/CVI prototype adapter may interface touser-supplied code modules having a .dll, lib, .obj, or .c extension.The DLL flexible prototype adapter may interface to user-supplied codemodules having a .dll extension. The sequence adapter may interface tosequence files.

The test executive engine 220 may manage the execution of test executivesequences. Test executive sequences include test executive steps thatmay call external or user-supplied code modules. By using moduleadapters 240 that have the standard adapter interface 232, the testexecutive engine 220 may invoke execution of different types ofuser-supplied code modules. Thus, the test executive may be independentfrom particular application development environments (ADEs) used tocreate the user-supplied code modules. In one embodiment, the testexecutive may use a special type of sequence called a process model todirect the high-level sequence flow. The test executive engine 220 mayimplement an application programming interface (API) used by thesequence editor 212 and run-time operator interfaces 202.

Sequence Editor

The sequence editor 212 may comprise a program in which the usercreates, edits, and/or debugs test executive sequences. The sequenceeditor 212 may have a graphical user interface (GUI) enabling a user toefficiently create a test executive sequence for testing a physicalsystem or unit under test. The graphical user interface of the sequenceeditor 212 may enable the user to request or select steps to be added toa test executive sequence and configure the steps. The graphical userinterface may provide the user with easy access to test executivefeatures, such as step types, step properties, sequence parameters, stepresult collection, etc.

FIG. 4 illustrates one example of a test executive sequence, createdaccording to one embodiment of a sequence editor 212. The exemplary testexecutive sequence of FIG. 4 includes a plurality of test executivesteps that call user-supplied code modules operable to test variousaspects of a computer system under test. For example, the sequenceincludes a “ROM” step that calls a user-supplied code module to test thecomputer's read-only memory, a “RAM” step that calls a user-suppliedcode module to test the computer's random access memory, etc. Eachuser-supplied code module called by a step in the test executivesequence may interact with one or more hardware devices or instrumentsthat interface with the computer system under test to perform thedesired test.

The user may be able to set various properties or parameters for eachstep that affect the way the test executive engine 220 manages theexecution of the step. For example, the sequence editor 212 may providea dialog box or other graphical user interface for each step with whichthe user may interact to specify the properties or parameters for thestep. For example, FIG. 5 illustrates an exemplary dialog box for the“Video” step of the test executive sequence of FIG. 4. As shown, a “RunOptions” property page is selected in FIG. 5. The “Run Options” propertypage enables the user to specify various options for the step, such aswhether to collect test results for the step, whether to break executionwhen the step is reached, whether to pre-load the step when opening thesequence file, etc. Other property pages in the dialog box of FIG. 5,such as the “General”, “Post Actions”, “Loop Options”,“Synchronization”, and “Expressions” pages, enable the user to specifyother options or properties for the step. For example, the user mayprovide input to the “General” page to specify a user-supplied codemodule for the step to call, e.g., by selecting a file (and possibly amodule or function within the file) representing the user-supplied codemodule.

As described in detail below, in one embodiment the test executiveengine 220 may be operable to invoke user-supplied code modules forexecution in a separate process from the process in which the testexecutive engine 220 itself executes. In one embodiment the sequenceeditor 212 may provide a graphical user interface for setting variousproperties related to the process isolation for user-supplied codemodules. The sequence editor 212 may allow the user to specify globaloptions related to process isolation for all user-code modules called bysteps in the test executive sequence (such as whether everyuser-supplied code module should execute in an external process) and/ormay allow the user to specify process isolation options for individualsteps in the sequence (such as whether or not the user-supplied codemodule called by a specific step in the test executive sequence shouldexecute in an external process).

In one embodiment, the sequence editor 212 may also include an executionwindow that provides debugging tools for debugging test executivesequences. For example, the test executive application may providedebugging features such as breakpoints, single stepping, tracing, avariable display, and a watch window.

Test Executive Engine

The test executive engine 220 may be used when executing and debuggingtest executive sequences. The test executive engine 220 may also providea test executive engine application programming interface (API) thatenables another program to interface with the test executive engine 220in order to perform these actions. For example, a run-time operatorinterface application may request the test executive engine 220 toexecute a test executive sequence, stop execution of the test executivesequence, etc.

In one embodiment, the test executive engine 220 may export anobject-based or component-based API, which in one embodiment may be anActiveX Automation API. The sequence editor 212 and run-time operatorinterface applications 202 may call the test executive engine API. Theengine API may be called from any programming environment able to usethe API. For example, where the API comprises an ActiveX Automation API,the engine API may be called from any programming environment thatsupports access to ActiveX Automation servers. Thus, in variousembodiments, the engine API may be called from run-time operatorinterface applications 202 or test modules written in variousprogramming environments, including those that are written in LabVIEW,LabWindows/CVI, Microsoft Visual C++, Microsoft Visual Basic, Java, etc.

One task performed by the test executive engine 220 is to manage theexecution of test executive sequences. Executing a test executivesequence may comprise executing steps included in the test executivesequence. Not all steps in the test executive sequence are necessarilyexecuted. For example, the user may configure some steps to be skipped,e.g., depending on execution results of previous steps.

For a step that calls a user-supplied code module, executing the stepmay comprise invoking execution of the respective code module. Asdescribed above, the user-supplied code module may be constructed invarious ways, using any of various kinds of programming languages orapplication development environments. The user-supplied code module mayexecute independently from the test executive engine 220 and maypossibly be executed under control of its own execution environment orsubsystem.

In addition to these user-supplied code modules being executed, for eachstep, additional program instructions may be executed, wherein theseadditional program instructions are implemented by the test executiveengine 220 itself and provide additional functionality for the step. Inother words, these additional program instructions may be programinstructions of the test executive software, e.g., program instructionsof the test executive engine 220, rather than being defined by the user.As one example, when including a step in a test executive sequence, theuser may configure execution results of the step to be collected. Inthis example, when the step is executed, test executive engine 220program instructions operable to store the step results accordingly maybe executed in addition to the program instructions of a user-suppliedcode module that the step references.

In some instances, the additional program instructions that areimplemented by the test executive engine 220 may be executed before auser-supplied code module called by the step is invoked. In this case,the functionality that is performed before the user-supplied code moduleis invoked may be referred to as “pre-functionality”. In otherinstances, the additional program instructions that are implemented bythe test executive engine 220 may be executed after the user-suppliedcode module called by the step finishes execution. In this case, thefunctionality that is performed after the user-supplied code modulefinishes execution may be referred to as “post-functionality”. A stepmay have pre-functionality and/or post-functionality, or neither. Theterm “control functionality” may be used to collectively refer to thepre-functionality and post-functionality of a step.

It is noted that in one embodiment, not all steps of a test executivesequence must call a user-supplied code module. For example, the testexecutive software may provide some step types that primarily affectvarious aspects of sequence execution and are not designed to calluser-supplied code modules.

As a test executive sequence is executed, various results may begenerated. In one embodiment the test executive engine 220 may beoperable to automatically collect the results, e.g., may store theresults in one or more data structures. In various embodiments, theresults may be generated or structured in any of various ways. Forexample, in one embodiment, there may be one or more results for theunit under test (UUT) as a whole, as well as results for individualsteps in the sequence. The results may vary in data type as well.

Test Executive Steps

As described above, a test executive sequence comprises and defines anordering for a plurality of test executive steps. A test executive stepcan do many things, such as initializing an instrument, performing acomplex test, or making a decision that affects the flow of execution ina test executive sequence. Steps may perform these actions throughseveral types of mechanisms, including jumping to another step,executing an expression, calling a sub-sequence, or calling auser-supplied code module.

Steps may have custom properties which the user can set, e.g., byinteracting with a dialog box or other graphical user interface for thestep as described above. For steps that call user-supplied code modules,custom step properties may be useful for storing parameters to pass tothe user-supplied code module for the step. They may also serve aslocations for the user-supplied code module to store its results. Thetest executive API may be used to access the values of custom stepproperties from user-supplied code modules.

As described above, in one embodiment not all steps call user-suppliedcode modules. Some steps may perform standard actions that the userconfigures using a GUI panel or dialog box. In this case, custom stepproperties may be useful for storing configuration settings that theuser specifies.

Built-In Step Properties

As discussed above, in one embodiment test executive steps in a testexecutive sequence may have a number of built-in properties orparameters that the user can specify or configure. In one embodiment,built-in step properties may include properties such as:

“Preconditions” that allow the user to specify the conditions that mustbe true for the test executive engine 220 to execute the step during thenormal flow of execution in a sequence.

“Load/Unload Options” that allow the user to specify when the testexecutive software loads and unloads the code modules or subsequencesthat each step invokes.

“Run Mode” that allows a step to be skipped or forced to pass or failwithout executing the step module.

“Record Results” that allows the user to specify whether the testexecutive software collects the results of the step.

“Step Failure Causes Sequence Failure” that allows the user to specifywhether the test executive software sets the status of the testexecutive sequence to “Failed” when the status of the step is “Failed”.

“Ignore Run-Time Errors” that allows the user to specify whether thetest executive sequence continues execution normally after the step eventhough a run-time error occurs in the step.

“Post Actions” that allows the user to specify the execution ofcallbacks or jump to other steps after executing the step, depending onthe pass/fail status of the step or any custom condition.

“Loop” options that cause a single step to execute multiple times beforeexecuting the next step. The user can specify the conditions under whichto terminate the loop. The user can also specify whether to collectresults for each loop iteration, for the loop as a whole, or for both.

“Pre Expression” that allows the user to specify an expression to beevaluated before executing the step module.

“Post Expression” that allows the user to specify an expression to beevaluated after executing the step module.

“Status Expression” that allows the user to specify an expression to useto set the value of a “status” property of the step automatically.

FIG. 6—Process Isolation for User-Supplied Code Modules

As described above, when user-supplied code modules called by steps of atest executive sequence contain bugs, these bugs can cause the testexecutive engine 220 to crash if the user-supplied code modules areexecuted in the same process space as the test executive engine. FIG. 6is a flowchart diagram illustrating one embodiment of a method forisolating one or more user-supplied code modules called by steps of atest executive sequence for execution in a separate process other thanthe process in which the test executive engine 220 executes. It is notedthat FIG. 6 illustrates a representative embodiment, and alternativeembodiments are contemplated. Also, various elements may be combined,omitted, or performed in different orders.

In 401, a test executive application may be installed on a firstcomputer system, such as the host computer 102 described above. As usedherein, installing the test executive application on a computer systemmay include enabling the computer system to execute the test executiveapplication. For example, one or more executable files associated withthe test executive application or providing access to the test executiveapplication may be installed on the host computer 102. The testexecutive application may include a sequence editor 212 and a testexecutive engine 220, as described above.

In 403, a test executive sequence may be created using the testexecutive application installed in 401. For example, the test executivesequence may be created using the sequence editor 212 of the testexecutive application, as described above. Creating the test executivesequence may comprise including a plurality of test executive steps inthe test executive sequence in response to user input to the sequenceeditor 212, as described above. The user may also configure each of thesteps, e.g., by interacting with a GUI panel or dialog box for each stepto set various properties. As described above, at least a subset of thesteps in the test executive sequence may call user-supplied codemodules. For example, for each step that calls a user-supplied codemodule, the user may interact with a GUI panel to specify theuser-supplied code module to call.

In various embodiments the test executive sequence may be operable totest any of various kinds of units under test (UUT) or physical systems.For example, steps in the test executive sequence may call user-suppliedcode modules that are operable to connect through one or more hardwaredevices or instruments to analyze, measure, or control a unit under test(UUT) or process 150, such as described above with reference to FIG. 1.

In 404, process isolation may be enabled or turned on for user-suppliedcode modules called by at least a subset of the test executive steps inthe test executive sequence. As described below, for each test executivestep that calls a user-supplied code module for which process isolationis enabled, the test executive engine 220 may be operable to invoke theuser-supplied code module called by the step for execution in a separateprocess, i.e., a process other than the process in which the testexecutive engine 220 executes.

In one embodiment the user may provide user input indicating whichparticular steps or which particular user-supplied code modules toperform process isolation for during execution of the test executivesequence. For example, for each step in the sequence for which the userdesires process isolation, the user may set an option to enable processisolation for the step, e.g., by interacting with a GUI panel or dialogbox for the step.

In another embodiment, process isolation may be performed by default forevery step in the test executive sequence that calls a user-suppliedcode module. In this embodiment the test executive application may allowthe process isolation to be disabled or turned off for certain steps inthe test executive sequence if desired. For example, the user may beconfident that some user-supplied code modules are free of bugs and maychoose to disable process isolation for steps that call theseuser-supplied code modules in order to increase execution performance.

In 405, the test executive sequence may be executed under control of thetest executive application, e.g., under control of the test executiveengine 220 supplied by the test executive application. Executing thetest executive sequence may comprise executing each of the steps in thetest executive sequence. In various embodiments the test executivesequence may be executed to perform any of various kinds of tests on aunit under test (UUT) or process 150. For example, as described abovewith reference to FIG. 1, the host computer 102 may couple to one ormore instruments, and various test executive steps in the test executivesequence may call user-supplied code modules that are operable toconnect through the one or more instruments to analyze, measure, orcontrol the unit under test (UUT) or process 150.

For each step in the test executive sequence that calls a user-suppliedcode module for which process isolation is enabled, FIG. 6 indicatesseveral operations that the test executive engine 220 may perform whenexecuting the step. As described above, in one embodiment a step mayhave “pre-functionality” that is implemented by the test executiveengine 220, i.e., functionality to be performed before a user-suppliedcode module called by the step is executed. In 407 the test executiveengine 220 may execute the pre-functionality of the step in a firstprocess. In other words, the first process is the process in which thetest executive engine 220 itself executes. In another embodiment thestep may not have pre-functionality, and 407 may not be performed.

In 409, the test executive engine 220 may invoke the user-supplied codemodule called by the step for execution in another process separate fromthe first process. For example, the test executive engine 220 may beoperable to create a second process, pass the appropriate parameters forthe user-supplied code module to the second process, and request thesecond process to execute the user-supplied code module. The secondprocess may be operable to return any return value of the user-suppliedcode module to the test executive engine 220 in the first process. Thus,execution of the user-supplied code module called by the step may beisolated in an external process. This may prevent any bugs in theuser-supplied code module from corrupting memory in the test executiveengine's process or otherwise affecting execution of the test executiveengine 220.

As described above, in one embodiment the step may have“post-functionality” that is implemented by the test executive engine220, i.e., functionality to be performed after the user-supplied codemodule called by the step finishes executing. In 411 the test executiveengine 220 may execute the post-functionality of the step in the firstprocess. In another embodiment the step may not have post-functionality,and 411 may not be performed.

In one embodiment the test executive engine 220 may create a new processfor each step in the test executive sequence that calls a user-suppliedcode module for which process isolation is enabled. For example, newprocesses may be dynamically created for each of these steps duringexecution of the test executive sequence. In this embodiment, eachuser-supplied code module for which process isolation is enabled may beinvoked for execution in a different process, i.e., the process createdfor the respective step. In another embodiment, the test executiveengine 220 may create a single process to be used for all steps in thetest executive sequence that call user-supplied code modules for whichprocess isolation is enabled. For example, the test executive engine 220may create a single second process which is separate from the firstprocess in which the test executive engine 220 executes and may causeeach user-supplied code module for which process isolation is enabled tobe executed in this same second process. For example, the second processmay be created when the test executive sequence begins execution and maybe used to execute each of the user-supplied code modules for whichprocess isolation is enabled.

In one embodiment the test executive engine 220 may be operable toexecute the test executive sequence in different modes, e.g., in eithera debug mode or a production mode. In one embodiment the test executiveengine 220 may be configured to invoke user-supplied code modules forexecution in a separate process from the process in which the testexecutive engine 220 itself executes if the test executive sequence isexecuted in debug mode but not if the test executive sequence isexecuted in production mode. Executing the test executive sequencewithout performing the process isolation for user-supplied code modulesmay increase execution performance of the test executive sequence. Inone embodiment the user may be able to turn process isolation on and offas desired, or the user may specify that process isolation should onlybe performed when executing the test executive sequence in certainexecution modes, e.g., in debug mode. For example, the user may interactwith a GUI panel to set these options.

The above-described method of isolating user-supplied code modules forexecution in a separate process from the process in which the testexecutive engine 220 executes may prevent bugs in the user-supplied codemodules from corrupting the process space of the test executive engine220, thus preventing the user-supplied code modules from causing thetest executive engine 220 to crash or exhibit other problematicbehavior. This may benefit users by helping them to track down the realsource of a problem encountered during execution of the test executivesequence.

It is noted that various embodiments may further include receiving,sending or storing instructions and/or data implemented in accordancewith the foregoing description upon a carrier medium.

Although the embodiments above have been described in considerabledetail, numerous variations and modifications will become apparent tothose skilled in the art once the above disclosure is fully appreciated.It is intended that the following claims be interpreted to embrace allsuch variations and modifications.

1. A carrier medium comprising program instructions executable to:include a plurality of test executive steps in a test executive sequencein response to user input, wherein each test executive step includescontrol functionality implemented by a test executive engine; configureeach of the test executive steps to call a user-supplied code module inresponse to user input; and execute the test executive sequence undercontrol of the test executive engine, wherein said executing comprisesthe test executive engine executing each of the test executive steps inthe test executive sequence; wherein for each test executive step in atleast a subset of the test executive steps in the test executivesequence, the test executive engine is operable to: execute the controlfunctionality of the test executive step in a first process; and invokethe user-supplied code module called by the test executive step forexecution in a different process other than the first process.
 2. Thecarrier medium of claim 1, wherein said including the plurality of testexecutive steps in the test executive sequence comprises including afirst test executive step in the test executive sequence; wherein thecontrol functionality of the first test executive step comprisespre-functionality implemented by the test executive engine, wherein thepre-functionality comprises functionality to be performed before theuser-supplied code module called by the first test executive step isexecuted; wherein the test executive engine executing the first testexecutive step comprises: the test executive engine executing thepre-functionality of the first test executive step in the first process;and the test executive engine invoking the user-supplied code modulecalled by the first test executive step for execution in a differentprocess other than the first process after said executing thepre-functionality of the first test executive step.
 3. The carriermedium of claim 1, wherein said including the plurality of testexecutive steps in the test executive sequence comprises including afirst test executive step in the test executive sequence; wherein thecontrol functionality of the first test executive step comprisespost-functionality implemented by the test executive engine, wherein thepost-functionality comprises functionality to be performed after theuser-supplied code module called by the first test executive stepfinishes execution; wherein the test executive engine executing thefirst test executive step comprises: the test executive engine invokingthe user-supplied code module called by the first test executive stepfor execution in a different process other than the first process; andthe test executive engine executing the post-functionality of the firsttest executive step in the first process after the user-supplied codemodule called by the first test executive step finishes execution. 4.The carrier medium of claim 1, wherein for each test executive step inthe at least a subset of the test executive steps in the test executivesequence, the test executive engine is operable to: create a new processfor the test executive step, wherein said invoking the user-suppliedcode module called by the test executive step for execution in adifferent process other than the first process comprises invoking theuser-supplied code module called by the test executive step forexecution in the new process for the test executive step.
 5. The carriermedium of claim 1, wherein for each test executive step in the at leasta subset of the test executive steps in the test executive sequence,said invoking the user-supplied code module called by the test executivestep for execution in a different process other than the first processcomprises invoking the user-supplied code module called by the testexecutive step for execution in a second process, wherein eachuser-supplied code module called by a test executive step in the atleast a subset of the test executive steps in the test executivesequence executes in the second process.
 6. The carrier medium of claim1, wherein the program instructions are further executable to: receiveuser input specifying one or more of the test executive steps in thetest executive sequence for which process isolation is desired; whereinthe test executive engine is operable to invoke the user-supplied codemodules called by steps in the specified one or more test executivesteps for which process isolation is desired for execution in adifferent process other than the first process; wherein the testexecutive engine is operable to invoke the user-supplied code modulescalled by steps not in the specified one or more test executive stepsfor which process isolation is desired for execution in the firstprocess.
 7. The carrier medium of claim 1, wherein the programinstructions are further executable to display a graphical userinterface for creating the test executive sequence; wherein saidincluding the plurality of test executive steps in the test executivesequence is performed in response to user input received to thegraphical user interface requesting inclusion of the test executivesteps in the test executive sequence.
 8. The carrier medium of claim 1,wherein for each test executive step in the test executive sequence, theprogram instructions are further executable to display a graphical userinterface for configuring the test executive step; wherein for each testexecutive step in the test executive sequence, the test executive stepis configured to call a user-supplied code module in response to userinput received to the graphical user interface for configuring the testexecutive step, wherein the user input specifies the user-supplied codemodule.
 9. The carrier medium of claim 1, wherein for a first testexecutive step in the subset, said invoking the user-supplied codemodule called by the first test executive step for execution in adifferent process other than the first process comprises invoking afunction in a DLL for execution in a different process other than thefirst process.
 10. A carrier medium comprising program instructionsoperable to: execute a test executive sequence, wherein the testexecutive sequence comprises a plurality of test executive steps,wherein each test executive step includes control functionality, andwherein at least a subset of the test executive steps call auser-supplied code module; wherein said executing the test executivesequence comprises executing the control functionality of each of theplurality of test executive steps in a first process; wherein theplurality of test executive steps includes a first test executive stepthat calls a first user-supplied code module; wherein said executing thetest executive sequence comprises executing the first user-supplied codemodule called by the first test executive step in a second process. 11.A computer-implemented method comprising: including a plurality of testexecutive steps in a test executive sequence in response to user input,wherein each test executive step includes control functionalityimplemented by a test executive engine; configuring each of the testexecutive steps to call a user-supplied code module in response to userinput; and executing the test executive sequence under control of thetest executive engine, wherein said executing comprises the testexecutive engine executing each of the test executive steps in the testexecutive sequence; wherein for each test executive step in at least asubset of the test executive steps in the test executive sequence, thetest executive engine is operable to: execute the control functionalityof the test executive step in a first process; and invoke theuser-supplied code module called by the test executive step forexecution in a different process other than the first process.
 12. Themethod of claim 11, wherein said including the plurality of testexecutive steps in the test executive sequence comprises including afirst test executive step in the test executive sequence; wherein thecontrol functionality of the first test executive step comprisespre-functionality implemented by the test executive engine, wherein thepre-functionality comprises functionality to be performed before theuser-supplied code module called by the first test executive step isexecuted; wherein the test executive engine executing the first testexecutive step comprises: the test executive engine executing thepre-functionality of the first test executive step in the first process;and the test executive engine invoking the user-supplied code modulecalled by the first test executive step for execution in a differentprocess other than the first process after said executing thepre-functionality of the first test executive step.
 13. The method ofclaim 11, wherein said including the plurality of test executive stepsin the test executive sequence comprises including a first testexecutive step in the test executive sequence; wherein the controlfunctionality of the first test executive step comprisespost-functionality implemented by the test executive engine, wherein thepost-functionality comprises functionality to be performed after theuser-supplied code module called by the first test executive stepfinishes execution; wherein the test executive engine executing thefirst test executive step comprises: the test executive engine invokingthe user-supplied code module called by the first test executive stepfor execution in a different process other than the first process; andthe test executive engine executing the post-functionality of the firsttest executive step in the first process after the user-supplied codemodule called by the first test executive step finishes execution. 14.The method of claim 11, wherein for each test executive step in the atleast a subset of the test executive steps in the test executivesequence, the test executive engine is operable to: create a new processfor the test executive step, wherein said invoking the user-suppliedcode module called by the test executive step for execution in adifferent process other than the first process comprises invoking theuser-supplied code module called by the test executive step forexecution in the new process for the test executive step.
 15. The methodof claim 1 1, wherein for each test executive step in the at least asubset of the test executive steps in the test executive sequence, saidinvoking the user-supplied code module called by the test executive stepfor execution in a different process other than the first processcomprises invoking the user-supplied code module called by the testexecutive step for execution in a second process, wherein eachuser-supplied code module called by a test executive step in the atleast a subset of the test executive steps in the test executivesequence executes in the second process.
 16. The method of claim 11,further comprising: receiving user input specifying one or more of thetest executive steps in the test executive sequence for which processisolation is desired; wherein the test executive engine is operable toinvoke the user-supplied code modules called by steps in the specifiedone or more test executive steps for which process isolation is desiredfor execution in a different process other than the first process;wherein the test executive engine is operable to invoke theuser-supplied code modules called by steps not in the specified one ormore test executive steps for which process isolation is desired forexecution in the first process.
 17. The method of claim 11, wherein fora first test executive step in the subset, said invoking theuser-supplied code module called by the first test executive step forexecution in a different process other than the first process comprisesinvoking a function in a DLL for execution in a different process otherthan the first process.
 18. A system comprising: a sequence editor; atest executive engine; a host computer operable to execute the sequenceeditor and the test executive engine; and a unit under test (UUT)coupled to the host computer; wherein the host computer is operable toexecute the sequence editor to create a test executive sequence fortesting the UUT, wherein said creating the test executive sequencecomprises including a plurality of test executive steps in the testexecutive sequence in response to user input to the sequence editor,wherein each test executive step includes control functionalityimplemented by the test executive engine, wherein said creating the testexecutive sequence further comprises configuring each of the testexecutive steps to call a user-supplied code module in response to userinput to the sequence editor; wherein the host computer is furtheroperable to execute the test executive engine, wherein the testexecutive engine is operable to control execution of the test executivesequence, wherein said controlling execution of the test executivesequence comprises causing each of the test executive steps in the testexecutive sequence to be executed on the host computer; wherein for eachtest executive step in at least a subset of the test executive steps inthe test executive sequence, the test executive engine is operable to:execute the control functionality of the test executive step on the hostcomputer in a first process; and invoke the user-supplied code modulecalled by the test executive step for execution on the host computer ina different process other than the first process.